<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <!-- 
    ！注意写上题目题数
    例如 ：
    1、选择题
        (1)...D
        (2)...C
        (3)...true false false
        (4)...C
        (5)...'obj1_name' 'obj1_name' 'obj2_name'


    2、填空题
     第一题
       1.(1)...document.getElementById() 
         (2)...document.getElementsByClassName()
         (3)...document.getElementsByName()
         (4)...document.getElementsByTagName()
         (5)... document.querySelector()
         (6)... document.querySelectorAll()

       2.(1)...document.createTextNode()
         (2)...document.createElement()
         (3)...document.createDocumentFragment()

       3.(1)...appendChild()
         (2)...node.append()
         (3)...node.replaceChild(newNode，oldNode)
         (4)...node.insertBefore( newElement,element)
         
       4.(1)...innerHTML 设置获取位于对象起始和结束标签内的html
         (2)...innterText   设置或获取位于对象起始和结束标签内的文本


     第二题
     1. object.__proto__ === Object.prototype
     2. fn.__proto__ === Function.prototype
     3.fn.__proto__.__proto__ === Object.prototype
     4.array.__proto__ === Array.prototype
     5.array.__proto__.__proto__ ===Object.prototype
     6.Function.__proto__ ===Function.prototype
     7.Array.__proto__ ===Object.__proto__
     8.Object.__proto__ ===Function.prototype
     9. true.__proto__ ===Boolean.prototype
     10. Function.prototype.__proto__ === Object.prototype



     第三题
     1.用来存储和传输的一种格式，通常用于服务器向网页传递数据，ajax（阿贾克斯）执行异步网络请求，是一种创建动态网页技术
     ajax作用：是一种在无需刷新加载整个网页的情况下，能够更新部分网页内容的技术。
     
     2.(1)直接调用函数的时候，this指向的是全局window
       (2)对象调用函数，this指向的是这个对象
       (3)构造函数里面的this指向的是实例化的对象
       (4)绑定事件里的this指向的是事件对象
     
       3.(1)所有的同步代码都在主执行栈上调用，形成了一个执行栈
         (2)除了执行栈，还会有一个任务队列。只要异步操作执行完成，就到任务队列排队。
         (3)一旦执行栈的所有同步代码执行完毕之后，系统就会读取任务队列里面的异步任务，被读取的异步任务结束等待状态，进栈和出栈。
         (4)主线程不断的重复上面三步骤


       4.每一个JS函数中都有一个prototype（原型）属性，指向这个函数的原型对象，通过这个函数产生的实例对象都有一个__proto__（隐式原型）属性，这个属性也是指向同一个原型对象，所有的实例对象的属性都会继承这个原型对象的属性，原型对象上也有一个__proto__属性，指向的objec原型对象，所有的对象属性都会继承objec原型对象属性。而object原型对象的__proto__指向的是null。当我们访问对象的某个属性时，就会从实例对象，原型对象，object原型对象上层层寻找，由此形成原型链。而原型就是原型对象上的属性。


    第四题
    1.'GoodbyeJack'
    2. 10
    3. 21
    4. 667
    5. "Hy"    "Jack"
    6. jack HanMeiMei undefined
    7.1 1 2 



    第五题
    1.
    ES5模拟类
    function Solider(options){
     this.id=options.id
     this.hp=options.hp
    }
     Solider.prototype.attack=function(){}
     Solider.prototype.defend=function(){}
     solider=new Solider({id:'76',hp:98})
     


    2.
     <script>
      function ajax(_url, _data, _method) {
            // GET请求为默认请求
            let method = _method || "GET";
            // GET请求就直接默认是null
            let data = _data || null;
            // 返回Prmoise对象
            return new Promise((resolve, reject) => {
                // 实例化一个XMLHttpRequest对象
                let xhr = new XMLHttpRequest();
                if (method.toUpperCase() == "GET") {
                    let str = "?";
                    // 处理get请求的参数
                    for (let k in data) {
                        str += `${k}=${data[k]}&`;
                    };
                    str = str.slice(0, -1);
                    xhr.open(method, _url + str);
                } else {
                    xhr.open(method, _url);
                }
                // 设置默认请求头
                // 设置请求头格式为json格式
                xhr.setRequestHeader("Content-Type", "application/json");
                xhr.send(JSON.stringify(data));

                xhr.addEventListener("readystatechange", () => {
                    if (xhr.readyState == 4) {
                        if (xhr.status == 200) {
                            // 返回解析成功结果
                            resolve(JSON.parse(xhr.responseText));
                        } else {
                            // 拒绝
                            reject(JSON.parse(xhr.responseText));
                        }
                    }
                })
            })
        };



        //方法一
        let arr = [1, 2, 5, 2, 4, 5, 10, 2, 5, 1, 2, 4, 5, 8, 6, 4];
        // let arr1 = [];
        // for (let i = 0; i < arr.length; i++) {
        //     if (arr1.indexOf(arr[i]) == -1) {
        //         arr1.push(arr[i])
        //     }
        // }
        // console.log(arr1);


        //方法二
        // let arr2 = [];
        // for (let i = 0; i < arr.length; i++) {
        //     if (!arr2.includes(arr[i])) { //includes 检测数组是否有某个值
        //         arr2.push(arr[i]);
        //     }
        // }
        // console.log(arr2);

        //方法三
        // function fn(arr) {
        //     return arr.filter(function (item, idx, arr) {
        //         return arr.indexOf(item) === idx;
        //     })
        // }
        // console.log(fn(arr));

        //方法四
        // console.log([...new Set(arr)] );
     </script>
    -->
        
 
</body>

</html>